\section{Création de package installables pour R}
R permet l'installation et la création de packages. Un packages regroupe un ensemble de fonctions et de données accessible à l'utilisateur. Il contient aussi une documentation sur les fonctions accessibles à l'utilisateur.
\subsection{Créer le squelette du package}

Afin de créer la structure, ou le squelette, du package il faut d'abord charger dans l'environnement les fonctions que l'on souhaite encapsuler dans le package avec la commande \textit{source}. Un fois que toutes les fonctions sont présentes, il est nécessaire d'appeler la fonction \textit{package.skeleton}. Elle va créer un dossier respectant la structure d'un package R.

\begin{lstlisting}
> package.skeleton(name='package_test', code_files='mesFonctions.R')
\end{lstlisting}

\indent La fonction va créer une arborescence nommée \textit{package\_test}.
Ce dossier doit contenir les fichiers suivants : 
\begin{itemize}
\item \textit{DESCRIPTION} : ce document contient les informations générales
sur le package
\item \textbf{man} : ce dossier contient la documentation des fonctions et
du package.
\item \textit{NAMESPACE} : ce fichier permet de déterminer quelles fonctions
sont accessibles à l'utilisateur et les quelles sont privées.
\item \textbf{R} : ce dossier contient les scripts R.
\end{itemize}

\subsection{Le fichier \textit{DESCRIPTION}}
Ce fichier contient des informations générales sur le package et son contenu.
Il sera principalement interprété par des programmes. La syntaxe de ce fichier, 
bien que simple est stricte : 
\begin{lstlisting}
Champ: valeur
\end{lstlisting}
Il doit obligatoirement contenir les champs suivants : 
\begin{itemize}
\item \textbf{Package:} nom du package
\item \textbf{Type:} Package
\item \textbf{Title:} titre du package
\item \textbf{Version:} version actuelle
\item \textbf{Date:} date de création du package au format AAAA-MM-JJ
\item \textbf{Author:} le nom du ou des auteurs
\item \textbf{Maintainer:} l'adresse de la personne à contacter en cas de soucis avec le package
\item \textbf{Description:} un texte de présentation du package
\item \textbf{License:} la licence sous laquelle le package est placé.
\end{itemize}
~\\
Et il peut être complété par les champs suivants : 
\begin{itemize}
\item \textbf{Depends:} permet de spécifier qu'une certaine version de R ou d'autres packages sont nécessaires à l'utilisation du package. Par exemple : 
\begin{lstlisting}
Depends: R (>= 2.0), rgl
\end{lstlisting}
signifie que l'installation du package nécessite une version de R supérieure ou égale à la version 2.0 et que le package \textit{rgl} doit être installé.
\item \textbf{Suggests:} permet de donner une liste de packages qui ne sont pas nécessaire à l'utilisation basique du package mais permettent des fonctionalités annexes.
\end{itemize}

\subsection{Rédiger la documentation}

La documentation des fonctions du package se fait par le remplissage de fichiers \textit{.Rd} (pour R documentation). Ces fichiers sont abondaments commentés et leur remplissage se fait rapidement. Le format des fichiers est similaire à du Latex. Ils servirons à générer les man pages du package ainsi que la documentation en html et en pdf. Exemple de fichier \textit{.Rd} : 
\begin{lstlisting}
\name{maFonction}
\alias{maFonction}
\title{
titre de la man page
}
\description{
ce que fait ma fonction
}
\usage{
run()
}
...
\end{lstlisting}
\subsection{Le fichier NAMESPACE}
Ce fichier permet de définir quelles sont les fonctions, variables et environnements accessibles à l'utilisateur et lesquelles sont privées et encapsulées dans le package. Celà peut être spécifié de deux manières. La première consiste à faire une liste de toutes les fonctions accessibles à l'utilisateur.
\begin{lstlisting}
export(fonction1, fonction2, variable, environnement)
\end{lstlisting}
Cette méthode est fastidieuse et il y a un risque d'oublier un élément. C'est pourquoi R gère un mecanisme qui permet d'exporter les fonctions, variables et environnement respectant une expression régulière. Par exemple : 
\begin{lstlisting}
exportPattern("^[^\\.]")
\end{lstlisting}
Cette ligne spécifie que tous les éléments dont le nom ne commence pas par $'.'$ seront exportés. Tous les élements privés du package devront donc être nommés de cette manière :
\begin{lstlisting}
.fonctionPrivee <- function(){}
\end{lstlisting}

\subsection{Finaliser et installer le package}
Une fois que les fichiers et dossiers requis sont remplis il faut construire le package. Celà se fait avec la commande suivante en dehors de la console R : 
\begin{lstlisting}
$ R CMD build package_test
\end{lstlisting}

Cette comande va créer un fichier \textit{package\_test\_1.0.tar.gz}.
Ensuite il faut tester que le package puisse s'installer correctement
et fonctionne. Celà se fait avec la commande : \textit{check}
\begin{lstlisting}
$ R CMD check package_test_1.0.tar.gz
\end{lstlisting}

Une fois le package validé par la commande \textit{check}, il peut être distribué et installé dans un environnement R de la manière suivante : 
\begin{lstlisting}
> install.package('./package_test_1.0.tar.gz')
\end{lstlisting}

\section{Persistance des données}

Conserver des données en dehors des fonctions est souvent nécessaire (par exemple conserver les caractéristiques d'une scène 3D). Celà peut être géré de deux façon différentes.

\subsection{La super-affectation}
La super-affectation est la méthode pour affecter des variables 
globales en R. Cela passe par l'opérateur $<<-$ qui s'utilise 
de la façon suivate : 

\begin{lstlisting}
> x <<- c(5,5,5)
\end{lstlisting}

Ce morceau de code signifie que la variable x, contenant un vecteur de 
taille 3 sera connu de n'importe quel environnement. On pourra y accéder
dans la console, dans des scripts, dans un package ; et celà reste vrai
quel que soit l'endroit où a été affecté x.
\\ \\
\indent Cette méthode est très facile à mettre en place et peu contraignante en terme de code. Elle est adaptée au scripts en dehors des packages et aux implémentations rapides. Cependant, comme dans n'importe quel autre langage de programmation une variable globale est dangereuse pour la
stabilité du code. En effet elle peut être accidentellement écrasée par une variable locale du même nom.


\subsection{Les environnements}
Afin de protéger les données critiques mais de les rendres tout de même accessibles, R permet de définir des environnements. Les environnements sont des pools de variables. Ils peuvent être protégés à l'intérieur d'un package (C.A.D. innaccessible depuis l'extérieur). Cependant, leur mise en place est un peu plus complexe. Elle se fait en plusieurs étapes : 
\begin{itemize}
\item Déclarer un nouvel environnement :
\begin{lstlisting}
> environnement <- new.env()
\end{lstlisting}
\item Ajouter des variables :
\begin{lstlisting}
> environnement$variable <- valeur
\end{lstlisting}
\item Utiliser les variables contenues dans l'environnement : 
\begin{lstlisting}
> variableLocale <- environnement$variable
\end{lstlisting}
\end{itemize}
De plus la déclaration de l'environnement doit se faire à un niveau supérieur que les éléments qui devront le connaitre. Exemple : 
\begin{lstlisting}
e1 <- new.env()

f <- function() {
  e2 <- new.env()
  g <- function() {
    e3 <- new.env()
  }
}

h <- function() {}
\end{lstlisting}

L'environnement $e1$ sera connu des fonctions $f$, $g$ et $h$, $e2$ ne sera connu que de $f$ et $g$. Enfin, $e3$ ne sera connu que de $g$.
\\ 
\indent Les environnements sont plus complexes à mettre en place que les super-affectations, cependant, ils permettent une encapsulation et une
protection des données internes à un package. Ils sont moins adaptés à l'utilisation dans un script ou en ligne de commande.
